home *** CD-ROM | disk | FTP | other *** search
/ BCI NET 2 / BCI NET 2.iso / archives / programming / source / term43-source.lha / Extras / Source / gtlayout-Source.lha / LT_LockWindow.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-10-21  |  3.2 KB  |  175 lines
  1. /*  GadTools layout toolkit
  2. **
  3. **  Copyright © 1993-1994 by Olaf `Olsen' Barthel
  4. **  Freely distributable.
  5. */
  6.  
  7. #include "gtlayout_global.h"
  8.  
  9. VOID LIBENT
  10. LT_LockWindow(REG(a0) struct Window *window)
  11. {
  12.     if(window)
  13.     {
  14.         LockNode    *lockNode;
  15.         BOOLEAN      found;
  16.  
  17.         found = FALSE;
  18.  
  19.         ObtainSemaphore(<P_LockSemaphore);
  20.  
  21.         SCANLIST(<P_LockList,lockNode)
  22.         {
  23.             if(lockNode -> Window == window)
  24.             {
  25.                 lockNode -> Count++;
  26.  
  27.                 found = TRUE;
  28.  
  29.                 break;
  30.             }
  31.         }
  32.  
  33.         if(!found)
  34.         {
  35.             if(lockNode = AllocMem(sizeof(LockNode),MEMF_PUBLIC | MEMF_ANY | MEMF_CLEAR))
  36.             {
  37.                 AddTail((struct List *)<P_LockList,(struct Node *)lockNode);
  38.  
  39.                 lockNode -> Window        = window;
  40.                 lockNode -> OldIDCMPFlags    = window -> IDCMPFlags;
  41.                 lockNode -> Count        = 1;
  42.                 lockNode -> MinWidth        = window -> MinWidth;
  43.                 lockNode -> MaxWidth        = window -> MaxWidth;
  44.                 lockNode -> MinHeight        = window -> MinHeight;
  45.                 lockNode -> MaxHeight        = window -> MaxHeight;
  46.  
  47.                 WindowLimits(window,window -> Width,window -> Height,window -> Width,window -> Height);
  48.  
  49.                 ModifyIDCMP(window,window -> IDCMPFlags | IDCMP_SIZEVERIFY);
  50.  
  51.                 if(V39)
  52.                 {
  53.                     SetWindowPointer(window,
  54.                         WA_BusyPointer,     TRUE,
  55.                         WA_PointerDelay,    TRUE,
  56.                     TAG_DONE);
  57.                 }
  58.                 else
  59.                 {
  60.                     STATIC UWORD __chip Stopwatch[(2 + 16) * 2] =
  61.                     {
  62.                         0x0000,0x0000,
  63.  
  64.                         0x0400,0x07C0,
  65.                         0x0000,0x07C0,
  66.                         0x0100,0x0380,
  67.                         0x0000,0x07E0,
  68.                         0x07C0,0x1FF8,
  69.                         0x1FF0,0x3FEC,
  70.                         0x3FF8,0x7FDE,
  71.                         0x3FF8,0x7FBE,
  72.                         0x7FFC,0xFF7F,
  73.                         0x7EFC,0xFFFF,
  74.                         0x7FFC,0xFFFF,
  75.                         0x3FF8,0x7FFE,
  76.                         0x3FF8,0x7FFE,
  77.                         0x1FF0,0x3FFC,
  78.                         0x07C0,0x1FF8,
  79.                         0x0000,0x07E0,
  80.  
  81.                         0x0000,0x0000
  82.                     };
  83.  
  84.                     SetPointer(window,Stopwatch,16,16,-6,0);
  85.                 }
  86.  
  87.                 Request(&lockNode -> Requester,window);
  88.             }
  89.         }
  90.  
  91.         ReleaseSemaphore(<P_LockSemaphore);
  92.     }
  93. }
  94.  
  95.  
  96. /****************************************************************************/
  97.  
  98.  
  99. VOID LIBENT
  100. LT_UnlockWindow(REG(a0) struct Window *window)
  101. {
  102.     if(window)
  103.     {
  104.         LockNode *lockNode;
  105.  
  106.         ObtainSemaphore(<P_LockSemaphore);
  107.  
  108.         SCANLIST(<P_LockList,lockNode)
  109.         {
  110.             if(lockNode -> Window == window)
  111.             {
  112.                 if(--lockNode -> Count < 1)
  113.                 {
  114.                     Remove((struct Node *)lockNode);
  115.  
  116.                     WindowLimits(window,lockNode -> MinWidth,lockNode -> MinHeight,lockNode -> MaxWidth,lockNode -> MaxHeight);
  117.  
  118.                     EndRequest(&lockNode -> Requester,window);
  119.  
  120.                     if(V39)
  121.                         SetWindowPointerA(window,NULL);
  122.                     else
  123.                         ClearPointer(window);
  124.  
  125.                     ModifyIDCMP(window,lockNode -> OldIDCMPFlags);
  126.  
  127.                     FreeMem(lockNode,sizeof(LockNode));
  128.                 }
  129.  
  130.                 break;
  131.             }
  132.         }
  133.  
  134.         ReleaseSemaphore(<P_LockSemaphore);
  135.     }
  136. }
  137.  
  138.  
  139. /*****************************************************************************/
  140.  
  141.  
  142. VOID LIBENT
  143. LT_DeleteWindowLock(REG(a0) struct Window *window)
  144. {
  145.     if(window)
  146.     {
  147.         LockNode *lockNode;
  148.  
  149.         ObtainSemaphore(<P_LockSemaphore);
  150.  
  151.         SCANLIST(<P_LockList,lockNode)
  152.         {
  153.             if(lockNode -> Window == window)
  154.             {
  155.                 Remove((struct Node *)lockNode);
  156.  
  157.                 EndRequest(&lockNode -> Requester,window);
  158.  
  159.                 if(V39)
  160.                     SetWindowPointerA(window,NULL);
  161.                 else
  162.                     ClearPointer(window);
  163.  
  164.                 ModifyIDCMP(window,lockNode -> OldIDCMPFlags);
  165.  
  166.                 FreeMem(lockNode,sizeof(LockNode));
  167.  
  168.                 break;
  169.             }
  170.         }
  171.  
  172.         ReleaseSemaphore(<P_LockSemaphore);
  173.     }
  174. }
  175.